```html
<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Gateway中的Filter机制 | 技术小馆</title>
    <link href="https://cdn.staticfile.org/font-awesome/6.4.0/css/all.min.css" rel="stylesheet">
    <link href="https://cdn.staticfile.org/tailwindcss/2.2.19/tailwind.min.css" rel="stylesheet">
    <link href="https://fonts.googleapis.com/css2?family=Noto+Serif+SC:wght@400;500;600;700&family=Noto+Sans+SC:wght@300;400;500;700&display=swap" rel="stylesheet">
    <style>
        body {
            font-family: 'Noto Sans SC', Tahoma, Arial, Roboto, "Droid Sans", "Helvetica Neue", "Droid Sans Fallback", "Heiti SC", "Hiragino Sans GB", Simsun, sans-serif;
            color: #333;
            line-height: 1.8;
        }
        h1, h2, h3, h4 {
            font-family: 'Noto Serif SC', serif;
            font-weight: 600;
        }
        .hero {
            background: linear-gradient(135deg, #6e8efb 0%, #a777e3 100%);
        }
        .code-block {
            background-color: #2d3748;
            border-radius: 0.5rem;
            color: #f7fafc;
        }
        .filter-card {
            transition: all 0.3s ease;
            box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
        }
        .filter-card:hover {
            transform: translateY(-5px);
            box-shadow: 0 10px 15px rgba(0, 0, 0, 0.1);
        }
        .pros-cons-item {
            padding: 1.5rem;
            border-radius: 0.5rem;
            margin-bottom: 1rem;
        }
        .pros {
            background-color: #f0fdf4;
            border-left: 4px solid #10b981;
        }
        .cons {
            background-color: #fef2f2;
            border-left: 4px solid #ef4444;
        }
        .image-container {
            border-radius: 0.5rem;
            overflow: hidden;
            box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
        }
    </style>
</head>
<body class="bg-gray-50">
    <!-- Hero Section -->
    <section class="hero text-white py-20 px-4 md:px-0">
        <div class="container mx-auto max-w-5xl text-center">
            <h1 class="text-4xl md:text-5xl font-bold mb-6">Gateway中的Filter机制</h1>
            <p class="text-xl md:text-2xl opacity-90 mb-8">微服务架构中流量管控的核心组件</p>
            <div class="flex justify-center space-x-4">
                <span class="px-4 py-2 bg-white bg-opacity-20 rounded-full">#微服务</span>
                <span class="px-4 py-2 bg-white bg-opacity-20 rounded-full">#SpringCloud</span>
                <span class="px-4 py-2 bg-white bg-opacity-20 rounded-full">#网关设计</span>
            </div>
        </div>
    </section>

    <!-- Main Content -->
    <div class="container mx-auto max-w-5xl px-4 py-12">
        <!-- Introduction -->
        <section class="mb-16">
            <p class="text-lg leading-relaxed mb-8">
                在微服务架构中，网关（Gateway）作为流量的入口，承担着请求路由、负载均衡、限流熔断等多种核心功能。而 Gateway 的 Filter 机制更是其中的关键组件，它通过对请求和响应的灵活拦截与处理，为微服务提供了高度可定制化的能力。
            </p>
            <div class="image-container mb-8">
                <img src="https://cdn.nlark.com/yuque/0/2024/png/21449790/1732847211412-86f0ab44-0083-4f0a-b829-2300307ff1dc.png" alt="Gateway Filter机制示意图" class="w-full">
            </div>
            <p class="text-lg leading-relaxed">
                Filter 机制的独特之处在于它基于非阻塞的响应式模型，可以在不影响性能的前提下处理复杂的业务逻辑。它提供了两种主要过滤器：内置过滤器和自定义过滤器。内置过滤器涵盖了常见的功能，如添加请求头、修改响应体和限流，而自定义过滤器则允许我们根据实际需求，灵活地实现特定的功能。例如，企业系统中，我们可以使用过滤器实现请求的统一认证、动态路由或者流量调节，确保系统的高可用性和安全性。
            </p>
        </section>

        <!-- Overview Section -->
        <section class="mb-16">
            <h2 class="text-3xl font-bold mb-6 text-gray-800 border-b pb-2">Gateway Filter 机制概述</h2>
            <p class="text-lg leading-relaxed mb-6">
                Spring Cloud Gateway 的 Filter 机制是其核心设计之一，用于在微服务架构中实现请求的前置处理和响应的后置处理。通过 Filter，开发者可以对请求的流经路径进行细粒度的拦截、修改和管控，从而满足复杂的业务需求。这种机制为微服务提供了高度的灵活性和可扩展性，同时利用 Spring WebFlux 的响应式特性，确保高性能和低资源开销。
            </p>
            <div class="image-container mb-6">
                <img src="https://cdn.nlark.com/yuque/0/2024/png/21449790/1732847247862-af9a4a27-58be-430e-aa95-9b6a51f93e4b.png" alt="Filter机制示意图" class="w-full">
            </div>
            
            <div class="grid md:grid-cols-2 gap-8 mb-8">
                <div class="bg-white p-6 rounded-lg shadow-md">
                    <h3 class="text-xl font-semibold mb-4 text-indigo-700"><i class="fas fa-project-diagram mr-2"></i>核心思想与设计</h3>
                    <p class="mb-4">Gateway Filter 机制采用的是基于过滤器链的设计模式。每个请求会按照配置依次通过一个过滤器链，过滤器分为两类：<strong>Pre Filter</strong> 和 <strong>Post Filter</strong>。</p>
                    <ul class="list-disc pl-5 space-y-2">
                        <li>Pre Filter 在请求被路由之前执行，用于处理请求的初始逻辑，如鉴权和参数校验</li>
                        <li>Post Filter 在请求被路由之后执行，用于处理响应数据或记录日志</li>
                    </ul>
                    <p class="mt-4">过滤器的执行顺序由配置中指定的顺序值（Order）控制，值越小优先级越高。这种有序执行的设计，确保了复杂的逻辑能够按照预期的流程逐步处理。</p>
                </div>
                
                <div class="bg-white p-6 rounded-lg shadow-md">
                    <h3 class="text-xl font-semibold mb-4 text-indigo-700"><i class="fas fa-filter mr-2"></i>Filter 的两种类型</h3>
                    <div class="mb-4">
                        <h4 class="font-medium text-lg text-green-600 mb-2">1. 内置过滤器</h4>
                        <p>Spring Cloud Gateway 提供了多种内置过滤器，能够满足常见的需求，避免开发者从头开始编写。</p>
                        <ul class="list-disc pl-5 mt-2 space-y-1">
                            <li><code>AddRequestHeader</code>：向请求添加特定的 HTTP 头部</li>
                            <li><code>ModifyResponseBody</code>：修改响应体内容</li>
                            <li><code>RequestRateLimiter</code>：实现基于 Redis 的请求限流</li>
                            <li><code>Hystrix</code>：提供熔断和降级支持</li>
                        </ul>
                    </div>
                    <div>
                        <h4 class="font-medium text-lg text-blue-600 mb-2">2. 自定义过滤器</h4>
                        <p>对于更复杂或特殊的场景，开发者可以实现自定义过滤器，扩展系统功能。通过实现 <code>GatewayFilter</code> 或 <code>GlobalFilter</code> 接口，可以灵活地定义自己的过滤逻辑，例如特定业务规则校验、日志采集等。</p>
                    </div>
                </div>
            </div>
            
            <div class="bg-white p-6 rounded-lg shadow-md">
                <h3 class="text-xl font-semibold mb-4 text-indigo-700"><i class="fas fa-hourglass-half mr-2"></i>过滤器的生命周期</h3>
                <div class="space-y-4">
                    <div>
                        <h4 class="font-medium text-gray-700 mb-2">1. 请求进入网关后</h4>
                        <p>Pre Filter 开始对请求进行前置处理，比如校验 Token、解密敏感参数、或重写请求路径。</p>
                    </div>
                    <div>
                        <h4 class="font-medium text-gray-700 mb-2">2. 请求路由到后端服务时</h4>
                        <p>路由器会将经过 Pre Filter 处理的请求转发至对应的微服务实例。</p>
                    </div>
                    <div>
                        <h4 class="font-medium text-gray-700 mb-2">3. 响应从微服务返回后</h4>
                        <p>Post Filter 对响应进行处理，比如添加统一的头信息、记录日志、或对响应体进行压缩和格式化。</p>
                    </div>
                </div>
            </div>
        </section>

        <!-- Working Principle Section -->
        <section class="mb-16">
            <h2 class="text-3xl font-bold mb-6 text-gray-800 border-b pb-2">Gateway Filter 的工作原理</h2>
            <p class="text-lg leading-relaxed mb-6">
                Spring Cloud Gateway 的 Filter 机制是其核心功能之一，基于过滤器链模型实现请求和响应的拦截与处理。它以响应式编程为基础，通过过滤器链对每个请求执行预定义或自定义的拦截逻辑，从而实现灵活、动态的流量管理。
            </p>
            <div class="image-container mb-8">
                <img src="https://cdn.nlark.com/yuque/0/2024/png/21449790/1732847298138-262a1efc-81bd-40ee-8553-159907a95587.png" alt="Filter工作原理图" class="w-full">
            </div>
            
            <div class="grid md:grid-cols-2 gap-8 mb-8">
                <div class="bg-white p-6 rounded-lg shadow-md">
                    <h3 class="text-xl font-semibold mb-4 text-indigo-700"><i class="fas fa-sitemap mr-2"></i>核心架构与执行流程</h3>
                    <div class="space-y-4">
                        <div>
                            <h4 class="font-medium text-gray-700 mb-2">1. 过滤器链模型（Filter Chain）</h4>
                            <p>Gateway 采用了责任链模式来组织过滤器。每个过滤器只负责自身的处理逻辑，执行完成后将请求传递给下一个过滤器。</p>
                        </div>
                        <div>
                            <h4 class="font-medium text-gray-700 mb-2">2. 路由匹配与过滤器绑定</h4>
                            <p>每个路由规则都会与特定的过滤器绑定。当网关接收到客户端请求时，会根据路由匹配逻辑选择合适的路由，并执行绑定到该路由的过滤器。</p>
                        </div>
                        <div>
                            <h4 class="font-medium text-gray-700 mb-2">3. 响应式编程支持</h4>
                            <p>基于 Spring WebFlux，Gateway Filter 的执行是完全非阻塞的。过滤器处理逻辑采用 Reactor 的 <code>Mono</code> 和 <code>Flux</code> 模型。</p>
                        </div>
                    </div>
                </div>
                
                <div class="bg-white p-6 rounded-lg shadow-md">
                    <h3 class="text-xl font-semibold mb-4 text-indigo-700"><i class="fas fa-code-branch mr-2"></i>执行流程解析</h3>
                    <ol class="list-decimal pl-5 space-y-4">
                        <li>
                            <strong>请求进入网关</strong>
                            <p class="pl-4">客户端发起请求后，Gateway 首先通过路由规则找到匹配的路由。</p>
                        </li>
                        <li>
                            <strong>Pre 阶段</strong>
                            <p class="pl-4">Pre 过滤器负责对请求的前置处理，包括校验请求参数、认证 Token、添加自定义 Header。</p>
                        </li>
                        <li>
                            <strong>请求转发至目标服务</strong>
                            <p class="pl-4">Pre 阶段执行完成后，Gateway 将处理后的请求转发到目标微服务实例。</p>
                        </li>
                        <li>
                            <strong>Post 阶段</strong>
                            <p class="pl-4">目标服务返回响应后，Post 过滤器链开始执行，负责处理响应逻辑。</p>
                        </li>
                        <li>
                            <strong>响应返回客户端</strong>
                            <p class="pl-4">Post 过滤器链执行完成后，最终的响应通过 Gateway 返回客户端。</p>
                        </li>
                    </ol>
                </div>
            </div>
            
            <div class="bg-white p-6 rounded-lg shadow-md">
                <h3 class="text-xl font-semibold mb-4 text-indigo-700"><i class="fas fa-tasks mr-2"></i>典型应用场景</h3>
                <div class="grid md:grid-cols-2 gap-4">
                    <div class="filter-card bg-white p-4 rounded-lg border border-gray-200">
                        <h4 class="font-semibold text-blue-600 mb-2"><i class="fas fa-shield-alt mr-2"></i>安全认证与授权</h4>
                        <p>在 Pre 阶段，验证请求是否携带有效的 Token 或用户凭证，未通过的请求直接终止路由。</p>
                    </div>
                    <div class="filter-card bg-white p-4 rounded-lg border border-gray-200">
                        <h4 class="font-semibold text-blue-600 mb-2"><i class="fas fa-random mr-2"></i>动态流量管理</h4>
                        <p>动态调整路由目标或流量分配策略，根据请求头信息实现 A/B 测试或蓝绿部署。</p>
                    </div>
                    <div class="filter-card bg-white p-4 rounded-lg border border-gray-200">
                        <h4 class="font-semibold text-blue-600 mb-2"><i class="fas fa-database mr-2"></i>数据增强与脱敏</h4>
                        <p>在 Post 阶段，修改响应体内容或脱敏敏感信息，统一响应数据格式。</p>
                    </div>
                    <div class="filter-card bg-white p-4 rounded-lg border border-gray-200">
                        <h4 class="font-semibold text-blue-600 mb-2"><i class="fas fa-chart-line mr-2"></i>日志采集与监控</h4>
                        <p>全局过滤器用于记录请求和响应日志，并埋点收集关键指标如延迟和状态码分布。</p>
                    </div>
                </div>
            </div>
        </section>

        <!-- Built-in Filters Section -->
        <section class="mb-16">
            <h2 class="text-3xl font-bold mb-6 text-gray-800 border-b pb-2">Gateway Filter 的内置过滤器</h2>
            <p class="text-lg leading-relaxed mb-8">
                Spring Cloud Gateway 提供了一系列功能强大的内置过滤器，用于处理请求和响应。这些过滤器解决了微服务架构中常见的流量管理、请求改写、安全认证、限流控制等问题。每个内置过滤器都有其独特的功能和应用场景，开发者可以通过路由规则直接配置和使用，无需重复开发。
            </p>
            
            <div class="bg-white rounded-lg shadow-md overflow-hidden mb-8">
                <div class="p-6">
                    <h3 class="text-xl font-semibold mb-4 text-indigo-700"><i class="fas fa-tools mr-2"></i>核心内置过滤器</h3>
                    <div class="grid md:grid-cols-2 gap-6">
                        <div class="p-4 border border-gray-200 rounded-lg">
                            <h4 class="font-semibold text-green-600 mb-2"><i class="fas fa-plus-circle mr-2"></i>AddRequestHeader</h4>
                            <p class="mb-2"><strong>功能：</strong>在请求进入目标服务前，动态添加一个或多个自定义的请求头。</p>
                            <p><strong>应用场景：</strong>用于在请求中附加额外信息，例如跟踪 ID、用户身份信息或特定的认证标识。</p>
                            <div class="code-block p-4 mt-3 rounded">
                                <pre class="text-sm text-gray-100"><code>filters:
  - name: AddRequestHeader
    args:
      name: X-Custom-Header
      value: CustomValue</code></pre>
                            </div>
                        </div>
                        
                        <div class="p-4 border border-gray-200 rounded-lg">
                            <h4 class="font-semibold text-green-600 mb-2"><i class="fas fa-exchange-alt mr-2"></i>RewritePath</h4>
                            <p class="mb-2"><strong>功能：</strong>修改请求路径，通过正则表达式替换指定路径片段。</p>
                            <p><strong>应用场景：</strong>实现路径重写以适配目标服务的 API 规范。</p>
                            <div class="code-block p-4 mt-3 rounded">
                                <pre class="text-sm text-gray-100"><code>filters:
  - name: RewritePath
    args:
      regexp: "/old-path/(?&lt;segment&gt;.*)"
      replacement: "/new-path/${segment}"</code></pre>
                            </div>
                        </div>
                        
                        <div class="p-4 border border-gray-200 rounded-lg">
                            <h4 class="font-semibold text-green-600 mb-2"><i class="fas fa-tachometer-alt mr-2"></i>RequestRateLimiter</h4>
                            <p class="mb-2"><strong>功能：</strong>对请求实施限流控制，支持基于 Redis 的令牌桶算法。</p>
                            <p><strong>应用场景：</strong>对 API 的访问频率进行限制，防止流量激增导致服务不可用。</p>
                            <div class="code-block p-4 mt-3 rounded">
                                <pre class="text-sm text-gray-100"><code>filters:
  - name: RequestRateLimiter
    args:
      redis-rate-limiter.replenishRate: 10
      redis-rate-limiter.burstCapacity: 20</code></pre>
                            </div>
                        </div>
                        
                        <div class="p-4 border border-gray-200 rounded-lg">
                            <h4 class="font-semibold text-green-600 mb-2"><i class="fas fa-redo mr-2"></i>Retry</h4>
                            <p class="mb-2"><strong>功能：</strong>在请求失败时，自动重试特定次数。</p>
                            <p><strong>应用场景：</strong>用于增强请求的可靠性，例如网络波动导致的请求超时或失败。</p>
                            <div class="code-block p-4 mt-3 rounded">
                                <pre class="text-sm text-gray-100"><code>filters:
  - name: Retry
    args:
      retries: 3
      statuses: 500, 502</code></pre>
                            </div>
                        </div>
                    </div>
                </div>
            </div>
            
            <div class="bg-white p-6 rounded-lg shadow-md">
                <h3 class="text-xl font-semibold mb-4 text-indigo-700"><i class="fas fa-cogs mr-2"></i>内置过滤器的执行流程</h3>
                <ol class="list-decimal pl-5 space-y-3">
                    <li><strong>配置与绑定</strong> - 开发者通过 <code>application.yml</code> 或 Java API 配置内置过滤器，绑定到特定路由或全局应用。</li>
                    <li><strong>预处理与后处理</strong> - 根据过滤器类型，分为 Pre 阶段和 Post 阶段执行，处理请求路径、参数、响应内容等。</li>
                    <li><strong>异步化执行</strong> - 所有内置过滤器均基于 Spring WebFlux，采用异步非阻塞的方式处理高并发场景。</li>
                </ol>
            </div>
        </section>

        <!-- Custom Filter Section -->
        <section class="mb-16">
            <h2 class="text-3xl font-bold mb-6 text-gray-800 border-b pb-2">自定义过滤器的实现步骤</h2>
            <p class="text-lg leading-relaxed mb-8">
                在 Spring Cloud Gateway 中，自定义过滤器用于实现内置过滤器无法满足的特殊需求。以下是实现自定义过滤器的详细步骤：
            </p>
            
            <div class="grid md:grid-cols-2 gap-8 mb-8">
                <div class="bg-white p-6 rounded-lg shadow-md">
                    <h3 class="text-xl font-semibold mb-4 text-indigo-700"><i class="fas fa-filter mr-2"></i>1. 明确自定义过滤器的类型</h3>
                    <div class="space-y-4">
                        <div>
                            <h4 class="font-medium text-green-600 mb-2">Global Filter</h4>
                            <ul class="list-disc pl-5">
                                <li><strong>作用范围：</strong>对所有路由生效</li>
                                <li><strong>应用场景：</strong>日志记录、认证校验、全局限流等通用逻辑</li>
                            </ul>
                        </div>
                        <div>
                            <h4 class="font-medium text-blue-600 mb-2">Route Filter</h4>
                            <ul class="list-disc pl-5">
                                <li><strong>作用范围：</strong>仅对绑定的特定路由生效</li>
                                <li><strong>应用场景：</strong>特定路由的路径改写、参数处理等</li>
                            </ul>
                        </div>
                    </div>
                </div>
                
                <div class="bg-white p-6 rounded-lg shadow-md">
                    <h3 class="text-xl font-semibold mb-4 text-indigo-700"><i class="fas fa-box-open mr-2"></i>2. 引入必要依赖</h3>
                    <p>在项目的 <code>pom.xml</code> 中确保引入以下依赖：</p>
                    <div class="code-block p-4 mt-3 rounded">
                        <pre class="text-sm text-gray-100"><code>&lt;dependency&gt;
    &lt;groupId&gt;org.springframework.cloud&lt;/groupId&gt;
    &lt;artifactId&gt;spring-cloud-starter-gateway&lt;/artifactId&gt;
&lt;/dependency&gt;</code></pre>
                    </div>
                </div>
            </div>
            
            <div class="bg-white p-6 rounded-lg shadow-md mb-8">
                <h3 class="text-xl font-semibold mb-4 text-indigo-700"><i class="fas fa-code mr-2"></i>3. 编写自定义过滤器类</h3>
                
                <div class="grid md:grid-cols-2 gap-6 mb-6">
                    <div>
                        <h4 class="font-medium text-green-600 mb-3">Global Filter 实现</h4>
                        <div class="code-block p-4 rounded">
                            <pre class="text-xs text-gray-100"><code>import org.springframework.cloud.gateway.filter.GlobalFilter;
import org.springframework.core.Ordered;
import org.springframework.stereotype.Component;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Mono;

@Component
public class CustomGlobalFilter implements GlobalFilter, Ordered {

    @Override
    public Mono&lt;Void&gt; filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        // Pre 阶段逻辑：记录请求信息
        System.out.println("CustomGlobalFilter: Request Path = " 
            + exchange.getRequest().getPath());
        
        // 执行下一个过滤器
        return chain.filter(exchange).then(
            Mono.fromRunnable(() -> {
                // Post 阶段逻辑：记录响应状态
                System.out.println("CustomGlobalFilter: Response Status = " 
                    + exchange.getResponse().getStatusCode());
            })
        );
    }

    @Override
    public int getOrder() {
        return 0; // 优先级，数值越小优先级越高
    }
}</code></pre>
                        </div>
                    </div>
                    
                    <div>
                        <h4 class="font-medium text-blue-600 mb-3">Route Filter 实现</h4>
                        <div class="code-block p-4 rounded">
                            <pre class="text-xs text-gray-100"><code>import org.springframework.cloud.gateway.filter.GatewayFilter;
import org.springframework.cloud.gateway.filter.factory.AbstractGatewayFilterFactory;
import org.springframework.stereotype.Component;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Mono;

@Component
public class CustomRouteFilter extends AbstractGatewayFilterFactory&lt;Config&gt; {

    public CustomRouteFilter() {
        super(Config.class);
    }

    @Override
    public GatewayFilter apply(Config config) {
        return (exchange, chain) -> {
            // Pre 阶段逻辑：在请求头中添加自定义信息
            exchange.getRequest().mutate()
                .header("X-Custom-Header", "CustomValue").build();

            return chain.filter(exchange).then(
                Mono.fromRunnable(() -> {
                    // Post 阶段逻辑：记录日志
                    System.out.println("CustomRouteFilter: Response Headers = " 
                        + exchange.getResponse().getHeaders());
                })
            );
        };
    }

    public static class Config {
        // 配置属性
    }
}</code></pre>
                        </div>
                    </div>
                </div>
            </div>
            
            <div class="bg-white p-6 rounded-lg shadow-md">
                <h3 class="text-xl font-semibold mb-4 text-indigo-700"><i class="fas fa-cog mr-2"></i>4. 注册和绑定过滤器</h3>
                
                <div class="grid md:grid-cols-2 gap-6">
                    <div>
                        <h4 class="font-medium text-green-600 mb-3">通过配置文件绑定</h4>
                        <div class="code-block p-4 rounded">
                            <pre class="text-sm text-gray-100"><code>spring:
  cloud:
    gateway:
      routes:
        - id: custom_route
          uri: http://demo.com
          filters:
            - name: CustomRouteFilter</code></pre>
                        </div>
                    </div>
                    
                    <div>
                        <h4 class="font-medium text-blue-600 mb-3">通过 Java 配置绑定</h4>
                        <div class="code-block p-4 rounded">
                            <pre class="text-xs text-gray-100"><code>import org.springframework.cloud.gateway.route.RouteLocator;
import org.springframework.cloud.gateway.route.RouteLocatorBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class GatewayConfig {

    @Bean
    public RouteLocator customRouteLocator(RouteLocatorBuilder builder) {
        return builder.routes()
            .route("custom_route", r -> r.path("/custom/**")
                .filters(f -> f.filter(new CustomRouteFilter()))
                .uri("http://demo.com"))
            .build();
    }
}</code></pre>
                        </div>
                    </div>
                </div>
            </div>
        </section>

        <!-- Application Scenarios Section -->
        <section class="mb-16">
            <h2 class="text-3xl font-bold mb-6 text-gray-800 border-b pb-2">Gateway Filter 的应用场景</h2>
            <p class="text-lg leading-relaxed mb-8">
                在微服务架构中，Spring Cloud Gateway 的 Filter 是一个强大的工具，用于实现请求和响应的预处理、后处理以及控制流量行为。以下是其主要应用场景：
            </p>
            
            <div class="grid md:grid-cols-2 gap-6">
                <div class="bg-white p-6 rounded-lg shadow-md">
                    <div class="flex items-start mb-4">
                        <div class="bg-blue-100 p-3 rounded-full mr-4">
                            <i class="fas fa-shield-alt text-blue-600 text-xl"></i>
                        </div>
                        <div>
                            <h3 class="text-xl font-semibold mb-2 text-gray-800">1. 请求认证与鉴权</h3>
                            <p>在微服务中，网关是进入服务的第一道关卡，过滤器可以验证请求的合法性。</p>
                            <div class="code-block p-3 mt-3 rounded">
                                <pre class="text-xs text-gray-100"><code>if (!isValidToken(exchange.getRequest()
    .getHeaders().get("Authorization"))) {
    return exchange.getResponse().setComplete();
}</code></pre>
                            </div>
                        </div>
                    </div>
                </div>
                
                <div class="bg-white p-6 rounded-lg shadow-md">
                    <div class="flex items-start mb-4">
                        <div class="bg-purple-100 p-3 rounded-full mr-4">
                            <i class="fas fa-random text-purple-600 text-xl"></i>
                        </div>
                        <div>
                            <h3 class="text-xl font-semibold mb-2 text-gray-800">2. 动态路由</h3>
                            <p>通过过滤器动态修改请求的目标地址，实现动态路由的功能。</p>
                            <div class="code-block p-3 mt-3 rounded">
                                <pre class="text-xs text-gray-100"><code>exchange.getRequest().mutate()
    .uri(URI.create(newTargetUri)).build();</code></pre>
                            </div>
                        </div>
                    </div>
                </div>
                
                <div class="bg-white p-6 rounded-lg shadow-md">
                    <div class="flex items-start mb-4">
                        <div class="bg-red-100 p-3 rounded-full mr-4">
                            <i class="fas fa-tachometer-alt text-red-600 text-xl"></i>
                        </div>
                        <div>
                            <h3 class="text-xl font-semibold mb-2 text-gray-800">3. 请求限流</h3>
                            <p>在高并发场景下，通过过滤器实现请求限流，保护后端服务不被过载。</p>
                            <ul class="list-disc pl-5 mt-2">
                                <li>对特定 IP 地址、用户、API 接口等设置限流策略</li>
                                <li>实现分布式限流，结合 Redis 或 Sentinel 等组件</li>
                            </ul>
                        </div>
                    </div>
                </div>
                
                <div class="bg-white p-6 rounded-lg shadow-md">
                    <div class="flex items-start mb-4">
                        <div class="bg-green-100 p-3 rounded-full mr-4">
                            <i class="fas fa-balance-scale text-green-600 text-xl"></i>
                        </div>
                        <div>
                            <h3 class="text-xl font-semibold mb-2 text-gray-800">4. 负载均衡与灰度发布</h3>
                            <p>过滤器可以动态调整流量分配策略，用于灰度发布或流量分流。</p>
                            <div class="code-block p-3 mt-3 rounded">
                                <pre class="text-xs text-gray-100"><code>if (Math.random() &lt; 0.1) {
    exchange.getRequest().mutate()
        .uri(newVersionUri).build();
}</code></pre>
                            </div>
                        </div>
                    </div>
                </div>
                
                <div class="bg-white p-6 rounded-lg shadow-md">
                    <div class="flex items-start mb-4">
                        <div class="bg-yellow-100 p-3 rounded-full mr-4">
                            <i class="fas fa-chart-bar text-yellow-600 text-xl"></i>
                        </div>
                        <div>
                            <h3 class="text-xl font-semibold mb-2 text-gray-800">5. 日志记录与监控</h3>
                            <p>过滤器能够捕获请求和响应的关键信息，用于日志记录或监控。</p>
                            <div class="code-block p-3 mt-3 rounded">
                                <pre class="text-xs text-gray-100"><code>long startTime = System.currentTimeMillis();
return chain.filter(exchange).then(
    Mono.fromRunnable(() -> {
        long duration = System.currentTimeMillis() - startTime;
        log.info("Request handled in " + duration + "ms");
    })
);</code></pre>
                            </div>
                        </div>
                    </div>
                </div>
                
                <div class="bg-white p-6 rounded-lg shadow-md">
                    <div class="flex items-start mb-4">
                        <div class="bg-indigo-100 p-3 rounded-full mr-4">
                            <i class="fas fa-lock text-indigo-600 text-xl"></i>
                        </div>
                        <div>
                            <h3 class="text-xl font-semibold mb-2 text-gray-800">6. 数据脱敏</h3>
                            <p>对请求或响应中的敏感信息进行脱敏处理，防止泄露敏感数据。</p>
                            <ul class="list-disc pl-5 mt-2">
                                <li>屏蔽日志中的用户密码或银行卡信息</li>
                                <li>隐藏返回给客户端的内部错误堆栈信息</li>
                            </ul>
                        </div>
                    </div>
                </div>
            </div>
        </section>

        <!-- Pros and Cons Section -->
        <section class="mb-16">
            <h2 class="text-3xl font-bold mb-6 text-gray-800 border-b pb-2">Gateway Filter 的优缺点</h2>
            <p class="text-lg leading-relaxed mb-8">
                在微服务架构中，Spring Cloud Gateway 的 Filter 机制作为一种请求处理工具，既能满足复杂的业务需求，又具有高灵活性。然而，任何技术都不是完美的，其优缺点在实际场景中需要权衡和考量。
            </p>
            
            <div class="grid md:grid-cols-2 gap-8">
                <div>
                    <h3 class="text-2xl font-semibold mb-6 text-green-600">优点</h3>
                    <div class="space-y-4">
                        <div class="pros-cons-item pros">
                            <h4 class="font-semibold text-lg mb-2">1. 高扩展性</h4>
                            <ul class="list-disc pl-5">
                                <li>支持内置过滤器和自定义过滤器，开发者可以根据需求扩展功能</li>
                                <li>基于 Spring Boot 和 Reactor 的编程模型，方便与其他 Spring 生态集成</li>
                            </ul>
                        </div>
                        
                        <div class="pros-cons-item pros">
                            <h4 class="font-semibold text-lg mb-2">2. 异步非阻塞模型</h4>
                            <ul class="list-disc pl-5">
                                <li>基于 WebFlux 的异步非阻塞模型，能够高效处理并发请求</li>
                                <li>减少线程资源占用，提高吞吐量和系统性能</li>
                            </ul>
                        </div>
                        
                        <div class="pros-cons-item pros">
                            <h4 class="font-semibold text-lg mb-2">3. 强大的过滤能力</h4>
                            <ul class="list-disc pl-5">
                                <li>提供丰富的内置过滤器，可以处理跨域请求、鉴权认证、限流、负载均衡等常见场景</li>
                                <li>支持在请求流（Pre Filter）和响应流（Post Filter）中进行精细化控制</li>
                            </ul>
                        </div>
                        
                        <div class="pros-cons-item pros">
                            <h4 class="font-semibold text-lg mb-2">4. 易于集成微服务架构</h4>
                            <ul class="list-disc pl-5">
                                <li>能与 Spring Cloud 全家桶无缝协作，比如 Eureka、Feign、Ribbon 等组件</li>
                                <li>作为微服务网关，过滤器机制可以集中管理安全、路由和性能优化等职责</li>
                            </ul>
                        </div>
                    </div>
                </div>
                
                <div>
                    <h3 class="text-2xl font-semibold mb-6 text-red-600">缺点</h3>
                    <div class="space-y-4">
                        <div class="pros-cons-item cons">
                            <h4 class="font-semibold text-lg mb-2">1. 开发复杂性较高</h4>
                            <ul class="list-disc pl-5">
                                <li>对于复杂场景，自定义过滤器的开发和调试需要熟悉 Reactive 编程模型</li>
                                <li>异步编程对开发者的技术要求较高，尤其是在处理复杂逻辑时，可能导致代码难以维护</li>
                            </ul>
                        </div>
                        
                        <div class="pros-cons-item cons">
                            <h4 class="font-semibold text-lg mb-2">2. 性能瓶颈</h4>
                            <ul class="list-disc pl-5">
                                <li>尽管 Gateway 使用异步非阻塞模型，但在高负载或大量复杂过滤器堆叠的情况下，性能可能会受到一定影响</li>
                                <li>对于需要极低延迟的场景（如金融交易系统），可能不如 Nginx 等原生网关高效</li>
                            </ul>
                        </div>
                        
                        <div class="pros-cons-item cons">
                            <h4 class="font-semibold text-lg mb-2">3. 功能依赖 Spring Cloud 生态</h4>
                            <ul class="list-disc pl-5">
                                <li>过于依赖 Spring Cloud 全家桶，若使用其他框架（如 Dubbo 或非 Java 服务），需要额外适配</li>
                                <li>在非 Spring Cloud 微服务体系下，其灵活性会受到限制</li>
                            </ul>
                        </div>
                        
                        <div class="pros-cons-item cons">
                            <h4 class="font-semibold text-lg mb-2">4. 调试和监控困难</h4>
                            <ul class="list-disc pl-5">
                                <li>Reactive 编程导致请求链路难以调试和监控，尤其是在出现复杂的依赖调用时</li>
                                <li>需要借助额外工具（如 Zipkin、Sleuth）才能跟踪请求流，增加了运维复杂度</li>
                            </ul>
                        </div>
                    </div>
                </div>
            </div>
        </section>
    </div>

    <!-- Footer -->
    <footer class="bg-gray-900 text-gray-300 py-8">
        <div class="container mx-auto max-w-5xl px-4 text-center">
            <div class="mb-4">
                <p class="text-lg font-medium">技术小馆</p>
                <a href="http://www.yuque.com/jtostring" class="text-blue-400 hover:text-blue-300 transition duration-300">http://www.yuque.com/jtostring</a>
            </div>
            <p class="text-sm">© 2024 技术小馆. All rights reserved.</p>
        </div>
    </footer>

    <script src="https://cdn.jsdelivr.net/npm/mermaid@latest/dist/mermaid.min.js"></script>
    <script>
        mermaid.initialize({
            startOnLoad: true,
            theme: 'default',
            flowchart: {
                useMaxWidth: true,
                htmlLabels: true,
                curve: 'basis'
            }
        });
    </script>
</body>
</html>
```